.TH std::basic_format_arg::handle 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::basic_format_arg::handle \- std::basic_format_arg::handle

.SH Synopsis
   Defined in header <format>
   template< class Context >                 \fI(since C++20)\fP
   class basic_format_arg<Context>::handle;

   A type-erased wrapper that allows formatting an object of a user-defined type.

   handle objects are typically created by std::make_format_args and accessed through
   std::visit_format_arg
   or the visit member functions of std::basic_format_arg
   (since C++26).

.SH Member functions

   format  formats the referenced object with the given contexts
   (C++20) \fI(public member function)\fP

std::basic_format_arg<Context>::handle::format

   void format( std::basic_format_parse_context<Context::char_type>&            (since
   parse_ctx,                                                                   C++20)
                Context& format_ctx ) const;

   Let

     * T be the type of the formatting argument,
     * TD be std::remove_const_t<T>,
     * TQ be const TD if const TD satisfies __formattable_with<Context> or TD
       otherwise, and
     * ref be a reference to the formatting argument.

   Equivalent to: typename Context::template formatter_type<TD> f;
   parse_ctx.advance_to(f.parse(parse_ctx));
   format_ctx.advance_to(f.format(const_cast<TQ&>(static_cast<const TD&>(ref)),
   format_ctx));

.SH Notes

   A handle has reference semantics for the formatted argument and does not extend its
   lifetime. It is the programmer's responsibility to ensure that the argument outlives
   the handle. Usually, a handle is only used within formatting functions.

.SH See also

   basic_format_arg  class template that provides access to a formatting argument for
   (C++20)           user-defined formatters
                     \fI(class template)\fP
   make_format_args  creates a type-erased object referencing all formatting arguments,
   make_wformat_args convertible to format_args
   (C++20)           \fI(function template)\fP
   (C++20)
